import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import 'storage_service.dart';
import 'rongcloud_service.dart';
import 'jpush_service.dart';
import '../api/index.dart';
import '../models/index.dart';

/// 用户服务 - 业务层服务
/// 
/// 🎯 核心职责：
/// - 用户登录/登出业务逻辑
/// - 用户信息管理和验证
/// - 用户权限控制
/// - 用户状态管理
/// - 用户数据持久化
class UserService extends GetxService {
  static UserService get to => Get.find<UserService>();
  
  // ==================== 用户服务存储键常量 ====================
  
  /// 用户访问令牌存储键
  static const String storageKeyUserToken = 'user_token';
  
  /// 用户刷新令牌存储键
  static const String storageKeyRefreshToken = 'refresh_token';
  
  /// 完整Token模型存储键
  static const String storageKeyTokenModel = 'token_model';
  
  /// 用户ID存储键（存储数字ID的字符串形式，如："1"）
  static const String storageKeyUserId = 'user_id';
  
  /// 用户名存储键
  static const String storageKeyUsername = 'username';
  
  /// 用户信息存储键
  static const String storageKeyUserInfo = 'user_info';
  
  /// 最后登录时间存储键
  static const String storageKeyLastLoginTime = 'last_login_time';
  
  /// 好友列表存储键
  static const String storageKeyFriendList = 'friend_list';

  // ==================== 时间/过期相关常量 ====================
  
  /// 默认访问令牌过期时间（秒）- 1小时
  static const int defaultAccessTokenExpiresIn = 3600;
  
  /// 默认刷新令牌过期时间（秒）- 1天
  static const int defaultRefreshTokenExpiresIn = 86400;
  
  /// 假设令牌获取时间偏移（毫秒）- 用于向后兼容
  static const int fallbackTokenObtainedOffset = 3300000;
  
  /// 登录信息过期天数
  static const int loginExpirationDays = 30;
  
  /// 未授权状态码
  static const int httpStatusUnauthorized = 401;
  
  // ==================== 依赖注入 ====================
  StorageService get _storageService => Get.find<StorageService>();
  
  // ==================== 响应式状态 ====================
  final _isLoggedIn = false.obs;
  final _currentUserProfile = Rxn<UserEntity>();
  final _userToken = ''.obs;
  final _refreshToken = ''.obs;
  
  // 好友列表相关状态
  final _friendList = <FriendEntity>[].obs;
  final _friendCount = 0.obs;
  
  // 好友申请列表相关状态
  final _friendRequestList = <FriendRequestEntity>[].obs;
  final _friendRequestCount = 0.obs;
  
  // ==================== 同步访问器 ====================
  bool get isLoggedIn => _isLoggedIn.value;
  UserEntity? get currentUserProfile => _currentUserProfile.value;
  UserEntity? get userInfo => _currentUserProfile.value;  // 🔥 兼容小程序的 userInfo 命名
  String get userToken => _userToken.value;
  String get refreshToken => _refreshToken.value;
  
  // 好友列表访问器
  List<FriendEntity> get friendList => _friendList;
  int get friendCount => _friendCount.value;
  
  // 好友申请列表访问器
  List<FriendRequestEntity> get friendRequestList => _friendRequestList;
  int get friendRequestCount => _friendRequestCount.value;
  
  // ==================== 响应式访问器 ====================
  RxBool get isLoggedInRx => _isLoggedIn;
  Rxn<UserEntity> get currentUserProfileRx => _currentUserProfile;
  RxString get userTokenRx => _userToken;
  RxString get refreshTokenRx => _refreshToken;
  
  // 好友列表响应式访问器（供监听使用）
  RxList<FriendEntity> get friendListRx => _friendList;
  RxInt get friendCountRx => _friendCount;
  
  // 好友申请列表响应式访问器（供监听使用）
  RxList<FriendRequestEntity> get friendRequestListRx => _friendRequestList;
  RxInt get friendRequestCountRx => _friendRequestCount;
  
  // ==================== 权限业务逻辑 ====================
  
  /// 检查用户是否有特定权限（核心业务逻辑）
  bool hasPermission(String permission) {
    // 新版本暂不支持权限检查
    // TODO: 实现具体权限检查逻辑
    return false;
  }
  
  /// 检查用户是否有特定角色（核心业务逻辑）
  bool hasRole(String role) {
    // 新版本暂不支持角色检查
    // TODO: 实现具体角色检查逻辑
    return false;
  }
  
  // ==================== 用户积分管理 ====================
  
  /// 🔥 更新用户积分（本地更新，不调用API）
  /// 
  /// 用于在本地同步更新用户积分，通常在积分扣除/增加后调用
  /// [newPoints] 新的积分值
  void updateUserPoints(int newPoints) {
    debugPrint('👤 UserService: 更新用户积分');
    debugPrint('   旧积分: ${_currentUserProfile.value?.userPoints ?? 0}');
    debugPrint('   新积分: $newPoints');
    
    if (_currentUserProfile.value != null) {
      // 创建新的UserEntity实例，更新积分
      final updatedUser = UserEntity(
        userid: _currentUserProfile.value!.userid,
        userPhone: _currentUserProfile.value!.userPhone,
        userEmail: _currentUserProfile.value!.userEmail,
        userCode: _currentUserProfile.value!.userCode,
        username: _currentUserProfile.value!.username,
        userGender: _currentUserProfile.value!.userGender,
        userAge: _currentUserProfile.value!.userAge,
        userAvatarUrl: _currentUserProfile.value!.userAvatarUrl,
        userSignature: _currentUserProfile.value!.userSignature,
        userTags: _currentUserProfile.value!.userTags,
        userData: _currentUserProfile.value!.userData,
        userLikes: _currentUserProfile.value!.userLikes,
        userFollowers: _currentUserProfile.value!.userFollowers,
        userPoints: newPoints,  // 🔥 更新积分
        userHobbies: _currentUserProfile.value!.userHobbies,
        userCity: _currentUserProfile.value!.userCity,
        userImgUrls: _currentUserProfile.value!.userImgUrls,
        userFrequentPlaces: _currentUserProfile.value!.userFrequentPlaces,
        userBirthday: _currentUserProfile.value!.userBirthday,
        userLevel: _currentUserProfile.value!.userLevel,
        status: _currentUserProfile.value!.status,
        extraData: _currentUserProfile.value!.extraData,
        createdAt: _currentUserProfile.value!.createdAt,
        lastLogin: _currentUserProfile.value!.lastLogin,
        updatedAt: _currentUserProfile.value!.updatedAt,
      );
      
      // 更新响应式状态
      _currentUserProfile.value = updatedUser;
      
      // 保存到本地存储
      _storageService.setString(
        storageKeyUserInfo,
        jsonEncode(updatedUser.toJson()),
      );
      
      debugPrint('✅ 用户积分已更新并保存');
    } else {
      debugPrint('⚠️ 当前用户信息为空，无法更新积分');
    }
  }
  
  // ==================== 生命周期 ====================
  @override
  Future<void> onInit() async {
    super.onInit();
    debugPrint('👤 UserService 初始化开始...');
    await _checkLoginStatus();
    debugPrint('✅ UserService 初始化完成');
  }
  
  @override
  void onClose() {
    debugPrint('🧹 UserService 正在清理...');
    super.onClose();
  }
  
  // ==================== 登录相关方法 ====================
  
  /// 用户登录（验证码登录）
  Future<LoginResp> login({
    required String userPhone,
  }) async {
    try {
      debugPrint('👤 开始用户登录（验证码）: $userPhone');
      
      // 调用新的验证码登录API
      final userProfile = await UserApi.login(userPhone: userPhone);
      
      debugPrint('✅ API登录成功，获取到用户信息');
      
      // 保存登录信息
      await _saveLoginInfo(userProfile, userPhone);
      
      debugPrint('✅ 用户登录成功: $userPhone');
      return LoginResp.success();
      
    } catch (e) {
      debugPrint('❌ 用户登录异常: $e');
      return LoginResp.failure('登录过程中发生错误，请重试');
    }
  }
  
  /// 用户退出登录
  Future<bool> logout() async {
    try {
      debugPrint('👤 用户退出登录');
      
      // 🔥 退出登录前先断开融云连接
      try {
        debugPrint('🔌 断开融云IM连接...');
        await RongCloudService.to.disconnect(receivePush: false);
        await RongCloudService.to.clearStorage();
        debugPrint('✅ 融云IM已断开');
      } catch (e) {
        debugPrint('⚠️ 断开融云IM失败: $e（不影响退出流程）');
      }
      
      await _clearAllStorageData();
        _clearUserState();
        
        debugPrint('✅ 用户退出登录成功');
        return true;
      
    } catch (e) {
      debugPrint('❌ 用户退出登录失败: $e');
      return false;
    }
  }
  
  // ==================== 用户信息管理 ====================
  
  /// 获取用户个人信息（对外接口）
  /// 
  /// 从服务器获取最新的用户信息并自动保存到本地
  /// 这是标准的服务层方法，供控制器层调用
  /// 会自动检查登录状态，未登录时抛出异常
  Future<UserEntity> getUserProfile() async {
    try {
      debugPrint('👤 开始获取用户个人信息');
      
      // ✅ 首先检查登录状态（服务层职责）
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法获取用户信息');
        throw Exception('用户未登录，请先登录');
      }
      
      // 获取当前用户手机号
      final userPhone = _currentUserProfile.value?.userPhone;
      if (userPhone == null || userPhone.isEmpty) {
        debugPrint('❌ 无法获取用户手机号');
        throw Exception('用户手机号不存在');
      }
      
      debugPrint('✅ 用户已登录，继续获取最新用户信息');
      
      // 调用 API 层获取用户信息（需要传入手机号）
      final userProfile = await UserApi.getUserProfile(userPhone);
      debugPrint('✅ 从服务器获取用户信息成功: ${userProfile.username}');
      
      // 自动保存到本地
      await setUserProfile(userProfile);
      debugPrint('✅ 用户信息已保存到本地');
      
      return userProfile;
      
    } catch (e) {
      debugPrint('❌ 获取用户个人信息失败: $e');
      rethrow; // 重新抛出异常，让调用者处理
    }
  }
  
  /// 设置用户信息（核心方法）
  Future<bool> setUserProfile(UserEntity userProfile) async {
    try {
      debugPrint('👤 设置用户信息: ${userProfile.username}');
      
      // 更新响应式状态
      _currentUserProfile.value = userProfile;
      
      // 保存到本地存储
      await _saveUserProfileToStorage(userProfile);
      
      debugPrint('✅ 用户信息设置成功');
      return true;
        
      } catch (e) {
      debugPrint('❌ 设置用户信息失败: $e');
      return false;
    }
  }
  
  // ==================== 头像管理方法 ====================
  
  /// 🎯 上传并更新用户头像（Service层统一处理）
  /// 
  /// 企业级最佳实践：
  /// 1. Service层负责所有API调用
  /// 2. Service层负责状态管理和数据同步
  /// 3. Controller只负责业务协调
  /// 
  /// @param imagePath - 本地图片路径
  /// @returns 上传结果
  Future<AvatarUploadResp> uploadAndUpdateAvatar(String imagePath) async {
    try {
      debugPrint('👤 Service: 开始上传并更新用户头像');
      
      // 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法上传头像');
        return AvatarUploadResp.failure('用户未登录');
      }
      
      final currentUserId = _currentUserProfile.value?.userid;
      if (currentUserId == null) {
        debugPrint('❌ 无法获取用户ID');
        return AvatarUploadResp.failure('用户信息异常');
      }
      
      // 1. 调用API上传头像
      debugPrint('📤 Service: 调用API上传头像');
      final uploadResult = await UserApi.uploadAvatar(
        imagePath,
        userId: currentUserId,
      );
      
      if (!uploadResult.success || uploadResult.imgUrl == null) {
        debugPrint('❌ 头像上传失败: ${uploadResult.errorMessage}');
        return uploadResult;
      }
      
      final newAvatarUrl = uploadResult.imgUrl!;
      debugPrint('✅ 头像上传成功: $newAvatarUrl');
      
      // 2. 调用API更新用户信息
      debugPrint('📝 Service: 调用API更新用户头像信息');
      final userPhone = _currentUserProfile.value?.userPhone;
      if (userPhone == null || userPhone.isEmpty) {
        debugPrint('❌ 无法获取用户手机号');
        return AvatarUploadResp.failure('用户手机号不存在');
      }
      
      final updatedProfile = await UserApi.updateUserProfile(
        userPhone: userPhone,
        userData: {'userAvatarUrl': newAvatarUrl},
      );
      
      // 3. 更新Service状态（自动触发响应式更新）
      debugPrint('🔄 Service: 更新本地状态');
      await setUserProfile(updatedProfile);
      
      debugPrint('✅ Service: 头像上传和更新完成');
      return AvatarUploadResp.success(newAvatarUrl);
      
    } catch (e) {
      debugPrint('❌ Service: 上传并更新头像失败: $e');
      return AvatarUploadResp.failure('上传头像失败: ${e.toString()}');
    }
  }
  
  // ==================== 实名认证管理方法 ====================
  
  /// 🎯 提交实名认证（Service层统一管理 - 企业级标准）
  /// 
  /// 职责：
  /// 1. 调用API提交实名认证
  /// 2. 更新用户信息中的realNameAuth字段
  /// 3. 保存到本地存储
  /// 4. 自动通知所有监听者
  Future<RealnameAuthResp> submitRealnameAuth({
    required String realName,
    required String idCardNo,
  }) async {
    try {
      debugPrint('🔐 Service: 开始提交实名认证');
      
      // 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法提交实名认证');
        return RealnameAuthResp.failure('用户未登录');
      }
      
      final userId = _currentUserProfile.value?.userid;
      if (userId == null) {
        debugPrint('❌ 无法获取用户ID');
        return RealnameAuthResp.failure('用户ID不存在');
      }
      
      debugPrint('📤 Service: 调用API提交实名认证');
      
      // 1️⃣ 调用API提交实名认证
      final result = await UserApi.realnameAuth(
        userId: userId,
        realName: realName,
        idCardNo: idCardNo,
      );
      
      if (result.success) {
        debugPrint('✅ 实名认证提交成功');
        
        // 2️⃣ 更新本地用户信息 - 重新获取最新用户信息
        debugPrint('🔄 Service: 更新本地用户信息');
        
        try {
          final userPhone = _currentUserProfile.value?.userPhone;
          if (userPhone != null && userPhone.isNotEmpty) {
            final refreshedProfile = await UserApi.getUserProfile(userPhone);
            await setUserProfile(refreshedProfile);
            debugPrint('✅ 用户信息已刷新，实名认证状态已同步');
          }
        } catch (e) {
          debugPrint('⚠️ 刷新用户信息失败: $e（不影响主流程）');
        }
        
        debugPrint('✅ Service: 实名认证提交完成');
        debugPrint('🎉 所有监听此Service的页面将自动同步更新');
        
        return result;
      } else {
        debugPrint('❌ 实名认证提交失败: ${result.message}');
        return result;
      }
      
    } catch (e) {
      debugPrint('❌ Service: 提交实名认证失败: $e');
      return RealnameAuthResp.failure('提交实名认证异常：${e.toString()}');
    }
  }
  
  
  // ==================== 用户信息更新方法 ====================
  
  /// 🎯 批量更新用户信息（Service层统一处理）
  /// 
  /// 企业级最佳实践：智能变更检测 + 批量更新
  /// 
  /// @param userData - 要更新的用户数据字段
  /// @returns 更新后的用户信息
  Future<UserEntity> updateUserInfo(Map<String, dynamic> userData) async {
    try {
      debugPrint('👤 Service: 开始批量更新用户信息');
      debugPrint('📊 更新字段: ${userData.keys.join(', ')}');
      
      // 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法更新信息');
        throw Exception('用户未登录');
      }
      
      final userPhone = _currentUserProfile.value?.userPhone;
      if (userPhone == null || userPhone.isEmpty) {
        debugPrint('❌ 无法获取用户手机号');
        throw Exception('用户手机号不存在');
      }
      
      // 1. 调用API更新用户信息
      debugPrint('📝 Service: 调用API批量更新用户信息');
      final updatedProfile = await UserApi.updateUserProfile(
        userPhone: userPhone,
        userData: userData,
      );
      
      // 2. 更新Service状态（自动触发响应式更新）
      debugPrint('🔄 Service: 更新本地状态');
      await setUserProfile(updatedProfile);
      
      debugPrint('✅ Service: 用户信息批量更新完成');
      return updatedProfile;
      
    } catch (e) {
      debugPrint('❌ Service: 批量更新用户信息失败: $e');
      rethrow;
    }
  }
  
  // ==================== 好友列表数据管理 ====================
  // 
  // 🎯 架构设计原则：
  // ✅ UserService 只负责：好友列表数据的获取、存储、状态管理
  // ✅ 控制器直接调用 FriendApi：发送申请、处理申请、删除好友、检查关系等操作
  // 
  // 这样做的好处：
  // 1. 职责单一：Service专注于数据管理，Controller专注于业务逻辑
  // 2. 灵活性高：不同页面可以根据需要直接调用API，无需通过Service中转
  // 3. 减少耦合：避免Service过于臃肿，降低维护成本
  
  /// 🎯 获取好友列表（仅负责数据获取和存储）
  /// 
  /// 职责：
  /// 1. 调用API获取好友列表
  /// 2. 更新响应式状态
  /// 3. 保存到本地存储
  /// 4. 自动通知所有监听者
  /// 
  /// ⚠️ 其他操作请直接调用 FriendApi：
  /// - 发送好友申请：FriendApi.sendFriendRequest()
  /// - 处理好友申请：FriendApi.handleFriendRequest()
  /// - 删除好友：FriendApi.deleteFriend()
  /// - 检查好友关系：FriendApi.checkFriendRelationship()
  Future<List<FriendEntity>> getFriendList({bool forceRefresh = false}) async {
    try {
      debugPrint('👥 Service: 开始获取好友列表');
      
      // 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法获取好友列表');
        throw Exception('用户未登录');
      }
      
      // 如果不强制刷新且缓存存在，返回缓存
      if (!forceRefresh && _friendList.isNotEmpty) {
        debugPrint('✅ 使用缓存的好友列表 (${_friendList.length}个)');
        return _friendList;
      }
      
      final userId = _currentUserProfile.value?.userid;
      if (userId == null) {
        debugPrint('❌ 无法获取用户ID');
        throw Exception('用户ID不存在');
      }
      
      debugPrint('📤 Service: 调用API获取好友列表');
      
      // 1️⃣ 调用API获取好友列表
      final request = FriendListReq(userId: userId);
      final response = await FriendApi.getFriendList(request);
      
      if (response['status'] == 'success') {
        // 🔥 API已经返回解析好的实体类列表，直接使用
        final friendList = (response['data'] as List).whereType<FriendEntity>().toList();
        final count = response['count'] as int;
        
        debugPrint('✅ API返回好友列表: $count 个好友');
        
        // 2️⃣ 更新响应式状态（自动通知所有监听者）
        debugPrint('🔄 Service: 更新好友列表状态');
        _friendList.value = friendList;
        _friendCount.value = count;
        
        // 3️⃣ 保存到本地存储
        await _saveFriendListToStorage(friendList);
        
        debugPrint('✅ Service: 好友列表获取完成');
        debugPrint('🎉 所有监听此Service的页面将自动同步更新');
        
        return friendList;
      } else {
        throw Exception(response['message'] ?? '获取好友列表失败');
      }
      
    } catch (e) {
      debugPrint('❌ Service: 获取好友列表失败: $e');
      rethrow;
    }
  }
  
  /// 保存好友列表到本地存储
  Future<void> _saveFriendListToStorage(List<FriendEntity> friendList) async {
    try {
      // 将好友列表转换为Map列表
      final friendListData = friendList.map((f) => f.toJson()).toList();
      
      // 保存为JSON数组
      final Map<String, dynamic> storageData = {
        'friends': friendListData,
        'count': friendList.length,
        'updatedAt': DateTime.now().toIso8601String(),
      };
      
      await _storageService.setObject(storageKeyFriendList, storageData);
      debugPrint('✅ 好友列表已保存到本地存储: ${friendList.length} 个');
    } catch (e) {
      debugPrint('⚠️ 保存好友列表失败: $e');
    }
  }
  
  /// 从本地存储加载好友列表
  Future<void> _loadFriendListFromStorage() async {
    try {
      final storageData = _storageService.getObject(storageKeyFriendList);
      
      if (storageData != null) {
        final friendListData = storageData['friends'];
        
        if (friendListData != null && friendListData is List) {
          final friendList = friendListData
              .map((item) => FriendEntity.fromJson(item as Map<String, dynamic>))
              .toList();
          
          _friendList.value = friendList;
          _friendCount.value = storageData['count'] ?? friendList.length;
          
          debugPrint('✅ 从本地存储加载好友列表: ${friendList.length} 个');
        }
      }
    } catch (e) {
      debugPrint('⚠️ 加载好友列表失败: $e');
    }
  }
  
  // ==================== 好友申请列表数据管理 ====================
  
  /// 🎯 获取好友申请列表（仅负责数据获取和存储）
  /// 
  /// 职责：
  /// 1. 调用API获取好友申请列表
  /// 2. 更新响应式状态
  /// 3. 保存到本地存储
  /// 4. 自动通知所有监听者
  /// 
  /// ⚠️ 处理好友申请请直接调用：FriendApi.handleFriendRequest()
  Future<List<FriendRequestEntity>> getFriendRequestList({bool forceRefresh = false}) async {
    try {
      debugPrint('📬 Service: 开始获取好友申请列表');
      
      // 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法获取好友申请列表');
        throw Exception('用户未登录');
      }
      
      // 如果不强制刷新且缓存存在，返回缓存
      if (!forceRefresh && _friendRequestList.isNotEmpty) {
        debugPrint('✅ 使用缓存的好友申请列表 (${_friendRequestList.length}个)');
        return _friendRequestList;
      }
      
      final userId = _currentUserProfile.value?.userid;
      if (userId == null) {
        debugPrint('❌ 无法获取用户ID');
        throw Exception('用户ID不存在');
      }
      
      debugPrint('📤 Service: 调用API获取好友申请列表');
      
      // 1️⃣ 调用API获取好友申请列表（接口已修复）
      final response = await FriendApi.getFriendRequestList(userId);
      
      if (response['status'] == 'success') {
        // 🔥 API已经返回解析好的实体类列表，直接使用
        final requestList = (response['data'] as List).whereType<FriendRequestEntity>().toList();
        final count = response['count'] as int;
        
        debugPrint('✅ API返回好友申请列表: $count 个申请');
        
        // 2️⃣ 更新响应式状态（自动通知所有监听者）
        debugPrint('🔄 Service: 更新好友申请列表状态');
        _friendRequestList.value = requestList;
        _friendRequestCount.value = count;
        
        // 3️⃣ 保存到本地存储
        await _saveFriendRequestListToStorage(requestList);
        
        debugPrint('✅ Service: 好友申请列表获取完成');
        debugPrint('🎉 所有监听此Service的页面将自动同步更新');
        
        return requestList;
      } else {
        throw Exception(response['message'] ?? '获取好友申请列表失败');
      }
      
    } catch (e) {
      debugPrint('❌ Service: 获取好友申请列表失败: $e');
      rethrow;
    }
  }
  
  /// 保存好友申请列表到本地存储
  Future<void> _saveFriendRequestListToStorage(List<FriendRequestEntity> requestList) async {
    try {
      // 将好友申请列表转换为Map列表
      final requestListData = requestList.map((r) => r.toJson()).toList();
      
      // 保存为JSON数组
      final Map<String, dynamic> storageData = {
        'requests': requestListData,
        'count': requestList.length,
        'updatedAt': DateTime.now().toIso8601String(),
      };
      
      await _storageService.setObject('friend_request_list', storageData);
      debugPrint('✅ 好友申请列表已保存到本地存储: ${requestList.length} 个');
    } catch (e) {
      debugPrint('⚠️ 保存好友申请列表失败: $e');
    }
  }
  
  /// 从本地存储加载好友申请列表
  Future<void> _loadFriendRequestListFromStorage() async {
    try {
      final storageData = _storageService.getObject('friend_request_list');
      
      if (storageData != null) {
        final requestListData = storageData['requests'];
        
        if (requestListData != null && requestListData is List) {
          final requestList = requestListData
              .map((item) => FriendRequestEntity.fromJson(item as Map<String, dynamic>))
              .toList();
          
          _friendRequestList.value = requestList;
          _friendRequestCount.value = storageData['count'] ?? requestList.length;
          
          debugPrint('✅ 从本地存储加载好友申请列表: ${requestList.length} 个');
        }
      }
    } catch (e) {
      debugPrint('⚠️ 加载好友申请列表失败: $e');
    }
  }
  
  // ==================== 好友数据刷新辅助方法 ====================
  
  /// 🔄 刷新好友列表（供控制器在操作完成后调用）
  /// 
  /// 使用场景：
  /// - 发送好友申请后，刷新申请列表
  /// - 同意/拒绝好友申请后，刷新申请列表和好友列表
  /// - 删除好友后，刷新好友列表
  /// 
  /// 示例：
  /// ```dart
  /// // 在控制器中
  /// await FriendApi.handleFriendRequest(requestId: id, action: 'accept');
  /// await UserService.to.refreshFriendData(); // 刷新数据
  /// ```
  Future<void> refreshFriendData({
    bool refreshFriendList = true,
    bool refreshRequestList = true,
  }) async {
    try {
      debugPrint('🔄 开始刷新好友数据...');
      
      if (refreshFriendList) {
        await getFriendList(forceRefresh: true);
      }
      
      if (refreshRequestList) {
        await getFriendRequestList(forceRefresh: true);
      }
      
      debugPrint('✅ 好友数据刷新完成');
    } catch (e) {
      debugPrint('❌ 刷新好友数据失败: $e');
      rethrow;
    }
  }
  
  /// 🔍 检查指定用户是否是我的好友
  /// 
  /// 用于判断某个用户是否在我的好友列表中
  /// 
  /// @param userId 要检查的用户ID
  /// @returns true=是好友，false=不是好友
  /// 
  /// 示例：
  /// ```dart
  /// final isFriend = UserService.to.isFriend(publisherId);
  /// if (!isFriend) {
  ///   // 显示加好友按钮
  /// }
  /// ```
  bool isFriend(int userId) {
    // 检查好友列表中是否存在该用户
    final exists = _friendList.any((friend) => friend.friendId == userId);
    debugPrint('🔍 检查用户 $userId 是否是好友: ${exists ? "是" : "否"}');
    return exists;
  }
  
  /// 📱 从好友列表中获取指定用户的手机号
  /// 
  /// 用于在活动数据中手机号缺失时，从好友列表中获取
  /// 
  /// @param userId 要查询的用户ID
  /// @returns 手机号，如果未找到返回null
  /// 
  /// 示例：
  /// ```dart
  /// final friendPhone = UserService.to.getFriendPhone(publisherId);
  /// if (friendPhone != null) {
  ///   // 使用手机号进行聊天
  /// }
  /// ```
  String? getFriendPhone(int userId) {
    try {
      // 在好友列表中查找该用户
      final friend = _friendList.firstWhere(
        (friend) => friend.friendId == userId,
        orElse: () => throw Exception('未找到好友'),
      );
      
      final phone = friend.userPhone;
      debugPrint('📱 从好友列表获取用户 $userId 的手机号: ${phone ?? "未知"}');
      return phone;
      
    } catch (e) {
      debugPrint('📱 用户 $userId 不在好友列表中，无法获取手机号');
      return null;
    }
  }
  
  // ==================== 数据获取方法 ====================
  

  
  /// 获取最后登录时间
  DateTime? getLastLoginTime() {
    try {
      final timeString = _storageService.getString(storageKeyLastLoginTime);
      return timeString != null ? DateTime.parse(timeString) : null;
    } catch (e) {
      debugPrint('❌ 获取最后登录时间失败: $e');
      return null;
    }
  }
  
  /// 获取完整的TokenEntity
  TokenEntity? getTokenModel() {
    try {
      final tokenData = _storageService.getObject(storageKeyTokenModel);
      return tokenData != null ? TokenEntity.fromJson(tokenData) : null;
    } catch (e) {
      debugPrint('❌ 获取TokenEntity失败: $e');
      return null;
    }
  }
  
  // ==================== 私有方法 ====================
  
  /// 检查登录状态
  Future<void> _checkLoginStatus() async {
    try {
      final token = _storageService.getString(storageKeyUserToken) ?? '';
      final refreshToken = _storageService.getString(storageKeyRefreshToken) ?? '';
      final userProfileData = _storageService.getObject(storageKeyUserInfo);
      
      if (token.isNotEmpty && userProfileData != null) {
        debugPrint('👤 发现已保存的登录信息');
        
        final userProfile = UserEntity.fromJson(userProfileData);
        
        _userToken.value = token;
        _refreshToken.value = refreshToken;
        _currentUserProfile.value = userProfile;
        _isLoggedIn.value = true;
        
        // 🔥 加载本地存储的好友列表
        await _loadFriendListFromStorage();
        
        // 🔥 加载本地存储的好友申请列表
        await _loadFriendRequestListFromStorage();
        
        // 检查登录是否过期
        await _checkLoginExpiration();
        
        // 🔥 应用启动时自动重连融云IM
        if (_isLoggedIn.value) {
          final rongcloudToken = userProfile.rongcloudToken;
          final rongcloudUserId = userProfile.rongcloudUserId;
          
          if (rongcloudToken.isNotEmpty && rongcloudUserId.isNotEmpty) {
            try {
              debugPrint('🔗 应用启动，检查融云IM连接状态...');
              debugPrint('   融云用户ID: $rongcloudUserId');
              
              // 🔥 智能连接：SDK内部会处理连接已存在的情况
              final connected = await RongCloudService.to.connect(
                token: rongcloudToken,
                userId: rongcloudUserId,
                timeout: 10,
              );
              
              if (connected) {
                debugPrint('✅ 融云IM连接就绪（可能是新连接或已存在的连接）');
              } else {
                debugPrint('⚠️ 融云IM连接失败');
              }
            } catch (e) {
              debugPrint('⚠️ 融云IM连接异常: $e');
            }
          } else {
            debugPrint('⚠️ 融云Token或用户ID为空，跳过连接');
          }
        }
      } else {
        debugPrint('👤 未找到登录信息');
        _clearUserState();
      }
      
    } catch (e) {
      debugPrint('❌ 检查登录状态失败: $e');
      _clearUserState();
    }
  }
  
  /// 检查登录过期
  Future<void> _checkLoginExpiration() async {
    try {
      final lastLoginTime = getLastLoginTime();
      if (lastLoginTime != null) {
        final daysSinceLogin = DateTime.now().difference(lastLoginTime).inDays;
        if (daysSinceLogin > loginExpirationDays) {
          debugPrint('⚠️ 登录信息已过期，自动退出登录');
          await logout();
        }
      }
    } catch (e) {
      debugPrint('❌ 检查登录过期失败: $e');
    }
  }
  
  /// 清除用户状态
  void _clearUserState() {
    _isLoggedIn.value = false;
    _currentUserProfile.value = null;
    _userToken.value = '';
    _refreshToken.value = '';
    
    // 🔥 清除好友列表状态
    _friendList.clear();
    _friendCount.value = 0;
    
    // 🔥 清除好友申请列表状态
    _friendRequestList.clear();
    _friendRequestCount.value = 0;
  }
  
  /// 🔥 使用用户信息登录（公共方法，供业务编排服务调用）
  /// 
  /// 职责：
  /// 1. 保存用户信息到本地
  /// 2. 更新响应式状态
  /// 3. 连接融云IM
  /// 4. 获取好友列表
  /// 
  /// @param userProfile 用户信息实体
  /// @param userPhone 用户手机号（用于保存）
  /// 
  /// 使用场景：
  /// - BusinessOrchestrationService.login() 调用
  /// - 自动登录
  /// - Token刷新后重新登录
  Future<void> loginWithUserInfo(UserEntity userProfile, String userPhone) async {
    debugPrint('👤 UserService: 使用用户信息登录');
    debugPrint('   用户ID: ${userProfile.userid}');
    debugPrint('   手机号: $userPhone');
    
    _isLoggedIn.value = true;
    _currentUserProfile.value = userProfile;
    
    // 从extraData中提取融云token
    final rongcloudToken = userProfile.rongcloudToken;
    final rongcloudUserId = userProfile.rongcloudUserId;
    
    if (rongcloudToken.isNotEmpty) {
      _userToken.value = rongcloudToken;
      debugPrint('✅ 已提取融云Token');
    }
    
    // 保存到存储
    if (rongcloudToken.isNotEmpty) {
      await _storageService.setString(storageKeyUserToken, rongcloudToken);
    }
    await _storageService.setString(storageKeyUserId, userProfile.userid.toString());
    await _storageService.setString(storageKeyUsername, userProfile.username ?? userPhone);
    await _storageService.setString(storageKeyLastLoginTime, DateTime.now().toIso8601String());
    await _saveUserProfileToStorage(userProfile);
    
    debugPrint('✅ 登录信息保存成功');
    
    // 🔥 登录成功后自动连接融云IM
    if (rongcloudToken.isNotEmpty && rongcloudUserId.isNotEmpty) {
      try {
        debugPrint('🔗 登录成功，开始连接融云IM...');
        debugPrint('   融云Token: ${rongcloudToken.substring(0, 20)}...');
        debugPrint('   融云用户ID: $rongcloudUserId');
        
        // 🔥 智能连接：SDK内部会处理连接已存在的情况（34001错误码）
        final connected = await RongCloudService.to.connect(
          token: rongcloudToken,
          userId: rongcloudUserId,
          timeout: 10,
        );
        
        if (connected) {
          debugPrint('✅ 融云IM连接就绪');
          
          // 🔥 连接成功后设置极光推送别名（用于后台推送）
          try {
            // 🔔 导入JPushService
            // import 'jpush_service.dart';
            final jpushService = Get.find<JPushService>();
            
            // 使用手机号作为推送别名（与融云用户ID一致）
            final alias = rongcloudUserId;
            debugPrint('🔔 设置极光推送别名: $alias');
            
            // 🔥 不等待别名设置完成，避免阻塞登录流程
            // 极光推送setAlias是异步回调机制，结果会通过JPushReceiver返回
            jpushService.setAlias(alias).then((aliasSet) {
              if (aliasSet) {
                debugPrint('✅ 极光推送别名设置成功');
                debugPrint('💡 现在服务端可以使用手机号推送消息了');
              } else {
                debugPrint('⚠️ 极光推送别名设置失败（不影响登录流程）');
              }
            }).catchError((e) {
              debugPrint('⚠️ 设置极光推送别名异常: $e（不影响登录流程）');
            });
            
            debugPrint('🔔 极光推送别名设置请求已发送（异步处理）');
          } catch (e) {
            debugPrint('⚠️ 设置极光推送别名异常: $e（不影响登录流程）');
          }
        } else {
          debugPrint('⚠️ 融云IM连接失败（不影响登录流程）');
        }
      } catch (e) {
        debugPrint('⚠️ 连接融云IM异常: $e（不影响登录流程）');
      }
    } else {
      debugPrint('⚠️ 融云Token或用户ID为空，跳过融云连接');
    }
    
    // 🔥 登录成功后自动获取好友列表
    try {
      debugPrint('👥 登录成功，开始获取好友列表...');
      await getFriendList(forceRefresh: true);
      debugPrint('✅ 好友列表获取完成');
    } catch (e) {
      debugPrint('⚠️ 获取好友列表失败: $e（不影响登录流程）');
    }
    
    debugPrint('✅ UserService: 登录流程完成');
  }
  
  /// 保存登录信息（私有方法，内部使用）
  /// 
  /// ⚠️ 已废弃，请使用 loginWithUserInfo()
  @Deprecated('使用 loginWithUserInfo() 代替')
  Future<void> _saveLoginInfo(UserEntity userProfile, String userPhone) async {
    // 🔥 直接调用公共方法
    await loginWithUserInfo(userProfile, userPhone);
  }
  
  /// 保存用户信息到存储
  Future<void> _saveUserProfileToStorage(UserEntity userProfile) async {
    final userProfileData = {
      ...userProfile.toJson(),
      'loginTime': DateTime.now().toIso8601String(),
    };
    
    await _storageService.setString(storageKeyUserId, userProfile.userid.toString());
    await _storageService.setString(storageKeyUsername, userProfile.username ?? '');
    await _storageService.setObject(storageKeyUserInfo, userProfileData);
  }
  
  /// 清除所有存储数据
  Future<void> _clearAllStorageData() async {
    final keys = [
      storageKeyUserToken,
      storageKeyRefreshToken,
      storageKeyTokenModel,
      storageKeyUserId,
      storageKeyUsername,
      storageKeyUserInfo,
      storageKeyLastLoginTime,
      storageKeyFriendList, // 🔥 清除好友列表存储
      'friend_request_list', // 🔥 清除好友申请列表存储
    ];
    
    for (final key in keys) {
      await _storageService.remove(key);
    }
    
    debugPrint('✅ 所有存储数据清除成功');
  }
  
}
